{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "60ed3d23",
   "metadata": {},
   "source": [
    "### 环境初始化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d0a42acf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 在jupyter notebook里env.render看不到窗口\n",
    "# 写一个helper类，用matplotlib刷新显示图像\n",
    "# 初始化传入env，调用helper的render即可\n",
    "from IPython import display # 导入display模块，用于在Jupyter Notebook中显示图像\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt # 导入matplotlib库，用于绘制图像\n",
    "%matplotlib inline\n",
    "\n",
    "class GymHelper:\n",
    "    def __init__(self, env, figsize = (3, 3)):\n",
    "        self.env = env # 初始化Gym环境\n",
    "        self.figsize = figsize # 初始化绘图窗口大小\n",
    "        \n",
    "        plt.figure(figsize = figsize) # 创建绘图窗口\n",
    "        plt.title(self.env.spec.id) # 标题设为环境名\n",
    "        self.img = plt.imshow(env.render()) # 在绘图窗口中显示初始图像\n",
    "    \n",
    "    def render(self, title = None):\n",
    "        image_data = self.env.render() # 获取当前环境图像渲染数据\n",
    "        \n",
    "        self.img.set_data(image_data) # 更新绘图窗口中的图像数据\n",
    "        display.display(plt.gcf()) # 刷新显示\n",
    "        display.clear_output(wait = True) # 有新图片时再清除绘图窗口原有图像\n",
    "        if title: # 如果有标题，就显示标题\n",
    "            plt.title(title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "10a33191",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入gym库\n",
    "import gym\n",
    "\n",
    "# 创建环境，指定渲染模式为rgb_array，如果是在IDE中可以改为'human'\n",
    "env = gym.make('LunarLander-v2', render_mode='rgb_array')\n",
    "# 重置环境\n",
    "env.reset()\n",
    "# 创建GymHelper\n",
    "gym_helper = GymHelper(env, figsize = (6, 6))\n",
    "\n",
    "# 循环N次\n",
    "for i in range(100):\n",
    "    gym_helper.render(title = str(i)) # 渲染环境\n",
    "    action = env.action_space.sample() # 从动作空间中随机选取一个动作\n",
    "    observation, reward, terminated, truncated, info = env.step(action) # 执行动作\n",
    "    if terminated or truncated: # 如果游戏结束，则结束循环\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a9127dc",
   "metadata": {},
   "source": [
    "### SAC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "27186235",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入必要的库\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import numpy as np\n",
    "import sys\n",
    "import time\n",
    "import random\n",
    "import collections\n",
    "from tqdm import * # 用于显示进度条\n",
    "\n",
    "# 策略模型，给定状态生成各个动作的概率\n",
    "class PolicyModel(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim):\n",
    "        super(PolicyModel, self).__init__()\n",
    "        \n",
    "        # 使用全连接层构建一个简单的神经网络，ReLU作为激活函数\n",
    "        # 最后加一个Softmax层，使得输出可以看作是概率分布\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(input_dim, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, output_dim),\n",
    "            nn.Softmax(dim = 1)\n",
    "        )\n",
    "\n",
    "    # 定义前向传播，输出动作概率分布\n",
    "    def forward(self, x):\n",
    "        action_prob = self.fc(x)\n",
    "        return action_prob\n",
    "\n",
    "# Q网络模型，给定状态和动作样本对估计Q值\n",
    "class QValueModel(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim):\n",
    "        super(QValueModel, self).__init__()\n",
    "        \n",
    "        # 网络结构和策略模型类似，输出维度为动作空间的维度\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(input_dim, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, output_dim)\n",
    "        )\n",
    "\n",
    "    # 定义前向传播，输出Q值估计\n",
    "    def forward(self, x):\n",
    "        value = self.fc(x)\n",
    "        return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b5260883",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 经验回放缓冲区\n",
    "class ReplayBuffer:\n",
    "    # 构造函数，max_size是缓冲区的最大容量\n",
    "    def __init__(self, max_size):\n",
    "        self.max_size = max_size\n",
    "        self.buffer = collections.deque(maxlen = self.max_size)  # 用collections的队列存储，先进先出\n",
    "\n",
    "    # 添加experience（五元组）到缓冲区\n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        experience = (state, action, reward, next_state, done)\n",
    "        self.buffer.append(experience)\n",
    "\n",
    "    # 从buffer中随机采样，数量为batch_size\n",
    "    def sample(self, batch_size):\n",
    "        batch = random.sample(self.buffer, batch_size)\n",
    "        state, action, reward, next_state, done = zip(*batch)\n",
    "        return state, action, reward, next_state, done\n",
    "    \n",
    "    # 返回缓冲区数据数量\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "01bbca6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# SAC算法\n",
    "class SAC:\n",
    "    # 构造函数，参数包含环境，学习率，折扣因子，更新目标网络参数，缓冲区大小\n",
    "    def __init__(self, env, learning_rate=0.001, gamma=0.99, rho=0.01, buffer_size=10000):\n",
    "        self.env = env\n",
    "        self.gamma = gamma\n",
    "        self.rho = rho\n",
    "        self.replay_buffer = ReplayBuffer(max_size=buffer_size)\n",
    "        \n",
    "        # 设置一个较大的目标熵值，取负值转为最小化问题\n",
    "        self.target_entropy = -np.log2(env.action_space.n)\n",
    "        \n",
    "        # 判断可用的设备是 CPU 还是 GPU\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "        \n",
    "        # 创建模型，并将模型移动到指定设备上\n",
    "        # 包括策略网络、两个Q值网络和它们对应的目标网络\n",
    "        self.actor = PolicyModel(env.observation_space.shape[0], env.action_space.n).to(self.device)\n",
    "        self.q1 = QValueModel(env.observation_space.shape[0], env.action_space.n).to(self.device)\n",
    "        self.q2 = QValueModel(env.observation_space.shape[0], env.action_space.n).to(self.device)\n",
    "        self.target_q1 = QValueModel(env.observation_space.shape[0], env.action_space.n).to(self.device)\n",
    "        self.target_q2 = QValueModel(env.observation_space.shape[0], env.action_space.n).to(self.device)\n",
    "        \n",
    "        # 将Q值网络的参数复制到对应的目标网络中，以确保初始的Q值网络和目标网络参数相同\n",
    "        for param, target_param in zip(self.q1.parameters(), self.target_q1.parameters()):\n",
    "            target_param.data.copy_(param)\n",
    "        for param, target_param in zip(self.q2.parameters(), self.target_q2.parameters()):\n",
    "            target_param.data.copy_(param)\n",
    "        \n",
    "        # 定义Adam优化器\n",
    "        self.optimizer_actor = torch.optim.Adam(self.actor.parameters(), lr=learning_rate)\n",
    "        self.optimizer_q1 = torch.optim.Adam(self.q1.parameters(), lr=learning_rate)\n",
    "        self.optimizer_q2 = torch.optim.Adam(self.q2.parameters(), lr=learning_rate)\n",
    "        \n",
    "        # alpha作为可学习参数，学习其对数值可确保alpha=exp(log_alpha)>0\n",
    "        self.log_alpha = torch.tensor([0.0], device=self.device, requires_grad=True)\n",
    "        self.optimizer_log_alpha = torch.optim.Adam([self.log_alpha], lr=learning_rate)\n",
    "\n",
    "    # 使用模型生成动作概率分布并采样\n",
    "    def choose_action(self, state):\n",
    "        # 将状态转换为tensor输入模型\n",
    "        state = torch.FloatTensor(np.array([state])).to(self.device)\n",
    "        with torch.no_grad():\n",
    "            action_prob = self.actor(state)\n",
    "        \n",
    "        # 生成分布后采样返回动作\n",
    "        c = torch.distributions.Categorical(action_prob)\n",
    "        action = c.sample()\n",
    "        return action.item()\n",
    "    \n",
    "    # 模型更新\n",
    "    def update(self, batch_size):\n",
    "        # 从经验回放缓冲区中随机采样，并将其转换为numpy数组\n",
    "        # 然后进一步转换为tensor，并将数据转移到指定计算资源设备上\n",
    "        states, actions, rewards, next_states, dones = self.replay_buffer.sample(batch_size)\n",
    "        states = torch.FloatTensor(np.array(states)).to(self.device)\n",
    "        actions = torch.tensor(np.array(actions)).view(-1, 1).to(self.device)\n",
    "        rewards = torch.FloatTensor(np.array(rewards)).view(-1, 1).to(self.device)\n",
    "        next_states = torch.FloatTensor(np.array(next_states)).to(self.device)\n",
    "        dones = torch.FloatTensor(np.array(dones)).view(-1, 1).to(self.device)\n",
    "        \n",
    "        ##### Q网络更新 #####\n",
    "        # 计算下一个状态的动作概率和对数\n",
    "        next_action_prob = self.actor(next_states)\n",
    "        log_next_prob = torch.log(next_action_prob + 1e-9) # 避免对零取对数\n",
    "        \n",
    "        # 计算目标Q值\n",
    "        target_q1 = self.target_q1(next_states)\n",
    "        target_q2 = self.target_q2(next_states)\n",
    "        target_q_min = torch.min(target_q1, target_q2)\n",
    "        min_q_next_target = next_action_prob * (target_q_min - torch.exp(self.log_alpha) * log_next_prob)\n",
    "        min_q_next_target = torch.sum(min_q_next_target, dim = 1, keepdim = True)\n",
    "        \n",
    "        # 计算TD目标\n",
    "        td_target = rewards + (1 - dones) * self.gamma * min_q_next_target\n",
    "        \n",
    "        # 计算Q网络的loss\n",
    "        q1 = self.q1(states)\n",
    "        q2 = self.q2(states)\n",
    "        q1_loss = F.mse_loss(q1.gather(1, actions), td_target.detach()).mean()\n",
    "        q2_loss = F.mse_loss(q2.gather(1, actions), td_target.detach()).mean()\n",
    "        \n",
    "        # 梯度清零、反向传播、更新参数\n",
    "        self.optimizer_q1.zero_grad()\n",
    "        self.optimizer_q2.zero_grad()\n",
    "        q1_loss.backward()\n",
    "        q2_loss.backward()\n",
    "        self.optimizer_q1.step()\n",
    "        self.optimizer_q2.step()\n",
    "        \n",
    "        ##### actor网络更新 #####\n",
    "        # 计算当前状态的动作概率\n",
    "        action_prob = self.actor(states)\n",
    "        log_prob = torch.log(action_prob + 1e-9)\n",
    "        \n",
    "        # 计算Q值和actor网络的loss\n",
    "        q1 = self.q1(states)\n",
    "        q2 = self.q2(states)\n",
    "        inside_term = torch.exp(self.log_alpha) * log_prob - torch.min(q1, q2)\n",
    "        actor_loss = torch.sum(action_prob * inside_term, dim = 1, keepdim = True).mean()\n",
    "        \n",
    "        # 梯度清零、反向传播、更新参数\n",
    "        self.optimizer_actor.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.optimizer_actor.step()\n",
    "        \n",
    "        ##### alpha参数更新 #####\n",
    "        # 计算alpha值的loss\n",
    "        inside_term = -torch.sum(action_prob * log_prob, dim = 1, keepdim = True) - self.target_entropy\n",
    "        alpha_loss = (torch.exp(self.log_alpha) * inside_term.detach()).mean()\n",
    "        # 梯度清零、反向传播、更新参数\n",
    "        self.optimizer_log_alpha.zero_grad()\n",
    "        alpha_loss.backward()\n",
    "        self.optimizer_log_alpha.step()\n",
    "        \n",
    "        ##### target网络更新 #####\n",
    "        for param, target_param in zip(self.q1.parameters(), self.target_q1.parameters()):\n",
    "            target_param.data.copy_(param.data * self.rho + target_param.data * (1 - self.rho))\n",
    "        for param, target_param in zip(self.q2.parameters(), self.target_q2.parameters()):\n",
    "            target_param.data.copy_(param.data * self.rho + target_param.data * (1 - self.rho))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "70e1e041",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 0: -163.5013329580238          \n",
      "Episode 50: -36.29076945067714                  \n",
      "Episode 100: 187.8184161425437                   \n",
      "Episode 150: 234.67211546406423                  \n",
      "Episode 200: 188.67339373402973                  \n",
      "Episode 250: 194.3653218215183                   \n",
      "Episode 300: 246.50879888790806                  \n",
      "Episode 350: 194.12872084437157                  \n",
      "Episode 400: 19.89901729067185                   \n",
      "Episode 450: 236.80490536022813                  \n",
      "100%|██████████| 500/500 [22:14<00:00,  2.67s/it]\n"
     ]
    }
   ],
   "source": [
    "# 定义超参数\n",
    "max_episodes = 500 # 训练episode数\n",
    "batch_size = 32 # 采样数\n",
    "\n",
    "# 创建SAC对象\n",
    "agent = SAC(env)\n",
    "# 定义保存每个回合奖励的列表\n",
    "episode_rewards = []\n",
    "\n",
    "# 开始循环，tqdm用于显示进度条并评估任务时间开销\n",
    "for episode in tqdm(range(max_episodes), file=sys.stdout):\n",
    "    # 重置环境并获取初始状态\n",
    "    state, _ = env.reset()\n",
    "    # 当前回合的奖励\n",
    "    episode_reward = 0\n",
    "\n",
    "    # 循环进行每一步操作\n",
    "    while 1:\n",
    "        # 根据当前状态选择动作\n",
    "        action = agent.choose_action(state)\n",
    "        # 执行动作，获取新的信息\n",
    "        next_state, reward, terminated, truncated, info = env.step(action)\n",
    "        # 判断是否达到终止状态\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        # 将这个五元组加到buffer中\n",
    "        agent.replay_buffer.add(state, action, reward, next_state, done)\n",
    "        # 累计奖励\n",
    "        episode_reward += reward\n",
    "\n",
    "        # 如果经验回放缓冲区已经有足够数据，就更新网络参数\n",
    "        if len(agent.replay_buffer) > batch_size:\n",
    "            agent.update(batch_size)\n",
    "        \n",
    "        # 更新当前状态\n",
    "        state = next_state\n",
    "\n",
    "        if done:\n",
    "            break\n",
    "    \n",
    "    # 记录当前回合奖励值\n",
    "    episode_rewards.append(episode_reward)\n",
    "    \n",
    "    # 打印中间值\n",
    "    if episode % (max_episodes // 10) == 0:\n",
    "        tqdm.write(\"Episode \" + str(episode) + \": \" + str(episode_reward))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "940033af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用Matplotlib绘制奖励值的曲线图\n",
    "plt.plot(episode_rewards)\n",
    "plt.title(\"reward\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "333fdf39",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 重置环境，开始新的一轮游戏\n",
    "observation, _ = env.reset()\n",
    "# 创建GymHelper对象来辅助显示\n",
    "gym_helper = GymHelper(env, figsize = (6, 6))\n",
    "episode_rewards = []\n",
    "\n",
    "# 开始游戏\n",
    "for i in range(1000):\n",
    "    # 渲染环境，title为当前步骤数\n",
    "    gym_helper.render(title = str(i))\n",
    "    \n",
    "    # 找到当前状态下的最优动作\n",
    "    action = agent.choose_action(observation)\n",
    "    # 执行action，获取新的信息\n",
    "    observation, reward, terminated, truncated, info = env.step(action)\n",
    "    episode_rewards.append(reward)\n",
    "    \n",
    "    # 如果游戏结束，则结束当前循环\n",
    "    if terminated or truncated:\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
